Forward event.session.created to WS clients (it was published on the core
bus but never forwarded) and re-emit event.session.status_changed(running)
on turn.started. v2 derives session status via ISessionActivity, a pure pull
that publishes nothing, so these v1 broadcasts were dropped: clients that
did not issue a create never learned the session existed, and the running
transition never reached kimi-web, whose Stop button is gated on
session.status === 'running'. Mirrors v1's SessionService status emission
and isGlobalSessionEvent fan-out.

- add PromptHarness/PromptSession interfaces so the print driver is
  decoupled from the concrete SDK harness/session
- add an in-process agent-core-v2 harness (bootstrap + session +
  prompt/goal/permission adapters) under cli/v2/
- adapt v2 IEventBus events to the v1 Event union, with unit tests
- select the engine in createPromptHarness via isKimiV2Enabled()
  (KIMI_CODE_EXPERIMENTAL_FLAG), lazy-importing v2 off the default path

- remove unused imports and variables
- add void to floating promises
- drop redundant return-await
- bind unbound method references
- replace == null with strict null/undefined checks
- add explicit sort comparators and Array.from helpers
- rename background_tasks capability to tasks
- migrate event sink to event bus in tests

- add a per-connection outbound send buffer in WsConnectionV1; sendFrame
  enqueues and a flush drains on a 16ms interval or once 64 frames queue
- coalesce adjacent volatile assistant/thinking deltas for the same
  session/agent/turn into one frame, keeping the first offset/seq so
  client alignment is unchanged
- defer flushing while socket.bufferedAmount exceeds a 1MiB high-water
  mark, merging new deltas into the queued frame instead of growing it
- flush remaining frames on close to avoid truncating the tail of a stream
- expose flushIntervalMs / maxBatchSize / highWaterMarkBytes via registerWsV1

- bridge split v2 status slices into one combined `agent.status.updated`
  event via a LegacyStatus derived model at the kap-server edge, so a
  usage-only event no longer overwrites the live context window with a
  stale zero
- fall back to the configured default model's context window when the
  agent has no model bound yet, so fresh sessions don't show "0/0"
- use `size` (measured + estimated) for the live context token count to
  mirror v1's `context.tokenCount`
- export `defineDerivedModel` / `DerivedModelDef` from agent-core-v2

- add custom onSend/onResponse access logging that records the envelope code
- disable Fastify built-in request logging (every response is HTTP 200)
- drop pino-pretty; logger always emits newline-delimited JSON
- rename dev:server-v2 script to dev:kap-server

The v2 server package is @moonshot-ai/kap-server, but three changesets still referenced the old @moonshot-ai/server-v2 name, which no longer exists in the workspace.

Subagents created via the Agent tool or AgentSwarm fell back to the
default `manual` permission mode because CreateAgentOptions offered no
way to seed one, so write/execute tool calls inside a subagent prompted
for approval even when the parent ran in auto/yolo.

Add an optional permissionMode to CreateAgentOptions and have the Agent
tool and AgentSwarm pass the caller's current mode when creating a
child.

- add reduceContextTranscript in agent-core-v2: keeps the full history across
  context.apply_compaction (summary marker instead of dropping the prefix) and
  stops context.undo at compaction summaries, matching v1's transcript view
- SnapshotReader: reduce the wire with the transcript reducer instead of the
  folded live context, so a later undo no longer hides the pre-compaction
  assistant reply
- MessageLegacyService: read the main agent wire log and merge the unflushed
  live tail instead of the folded IAgentContextMemoryService.get()

- v1 session route handlers and the sessionLegacy adapter resolved the target
  via ISessionLifecycleService.get, which only sees live (in-memory) sessions.
  A freshly-opened session is persisted (index + disk) but not live until the
  first prompt, so commands such as undo / fs:* / skills / :btw / warnings /
  terminals / profile / questions / approvals / archive reported
  `session does not exist` (40401).
- Resolve via ISessionLifecycleService.resume instead, which cold-loads a
  persisted session from disk (matches v1's resumeSession); a genuinely
  missing session still 404s.
- Add a cold-load regression for `:undo` and update the skills test for the
  new cold-load behaviour.

…into kimi-code-v2

…into kimi-code-v2

- add an Agent-scope runtime domain that holds the whole live phase as one discriminated-union field (idle, running, streaming, tool_call, retrying, awaiting_approval, interrupted, ended)
- drive it from existing turn, step, delta, tool, retry, interrupt and approval events, edge-triggered with reference-equality dedup so delta bursts do not flood the wire log
- carry the phase on the existing agent.status.updated channel and add the AgentPhase type/schema to the protocol (backward compatible)

…into kimi-code-v2

…into kimi-code-v2

Reconcile the parallel goal-mode work on goal-parity with origin's newer
kimi-code-v2 architecture. Conflicts resolved by keeping origin's
mechanisms and layering parity's behavior on top:

- goalService: keep origin's activity-lease continuation launch; graft
  parity's settleGoalAfterContinuationFailure so a failed relaunch pauses
  the goal instead of stranding it. Drop the orphaned tokenUsageTotal
  helper (accounting already charges ctx.usage.output) and its unused
  TokenUsage import; remove a duplicate MAX_GOAL_COMPLETION_CRITERION_LENGTH.
- update-goal: layer parity's outcome-prompt tool results and no-goal
  guards onto origin's goalIsActive stopBatch refinement.
- promptService / fullCompactionService: dedupe imports; keep both DI
  params (toolSelect and instantiation are each used).
- tests: align continuation tests to the lease model (hold the turn lane
  and mock launchWithLease), swap abortController for signal, and keep
  parity's token-accounting assertions to match the merged code.

Port v1 #1508 into v2: lower the longest-edge downscale cap back to
2000px (v2 was stuck on the 3000px it had ported from an earlier v1
change) and make it overridable, add the 256 KB read-image byte budget
used by ReadMediaFile, and widen the over-budget fallback ladder to
[2000, 1000, 768, 512, 384, 256].

- MAX_IMAGE_EDGE_PX 3000 -> 2000, with KIMI_IMAGE_MAX_EDGE_PX env and a
  config-pushed value resolved via resolveMaxImageEdgePx.
- READ_IMAGE_BYTE_BUDGET=256KB with KIMI_IMAGE_READ_BYTE_BUDGET env and
  resolveReadImageByteBudget; ReadMediaFile's default compress path now
  uses it (region / full_resolution still honor IMAGE_BYTE_BUDGET).
- Test expectations that hard-coded 3000px / 1500px updated to 2000 /
  1000 to match the v1 behavior.

The [image] config.toml section is intentionally not added: the env
vars already cover the override path, and wiring a config section plus
a runtime push would add v2-specific scaffolding beyond v1.

…aFile

Align with v1: a HEIC/HEIF read is now refused up front with an
os-specific conversion command (sips / heif-convert / ImageMagick) so the
unsupported format never reaches the provider (which would reject the
whole session once it lands in history). The two guidance builders are
ported verbatim from v1, and the check sits after the image-capability
guard (using IHostEnvironment.osKind).

Also give the existing EXIF-rotation test a longer timeout: it does
heavy jimp encode/decode and was flaking around the default 5s boundary.

Align with v1: expose `startBtw` on AgentAPI and delegate it to the
existing ISessionBtwService (already implemented and DI-registered as
SessionBtwService), so the /btw slash command can fork a side-question
child agent once the server runs on v2.

- Remove resume-debug.test.ts: a one-off diagnosis script with a
  hardcoded local path, not a real test.
- Move streamTiming.test.ts to app/model/modelImpl.test.ts: it only
  exercises buildStreamTiming in app/model/modelImpl.ts.
- Rename wire/store.test.ts to wire/wireServiceImpl.test.ts to match the
  module it covers (there is no store.ts in src).

Align with v1: replace the hand-rolled subset validator with v1's Ajv-
based implementation (draft-07/2019/2020 + ajv-formats), so tool-call
argument validation once again honors the JSON Schema `format` keyword
(and the full keyword set), not just the previously hard-coded subset.

- args-validator.ts is now byte-identical to v1 (93 lines, replacing the
  289-line hand-rolled subset).
- Adds ajv@^8.18.0 and ajv-formats@^3.0.1 (same versions as v1) plus the
  pnpm-lock.yaml update.
- The two call sites (compileToolArgsValidator -> validateToolArgs) keep
  working unchanged; a small test locks in format / required /
  additionalProperties / subset behavior.

Align with v1: replace the hand-rolled subset validator with v1's Ajv-
based implementation (draft-07/2019/2020 + ajv-formats), so tool-call
argument validation once again honors the JSON Schema `format` keyword
(and the full keyword set), not just the previously hard-coded subset.

- args-validator.ts is now byte-identical to v1 (93 lines, replacing the
  289-line hand-rolled subset).
- Adds ajv@^8.18.0 and ajv-formats@^3.0.1 (same versions as v1) plus the
  pnpm-lock.yaml update.
- The two call sites (compileToolArgsValidator -> validateToolArgs) keep
  working unchanged; a small test locks in format / required /
  additionalProperties / subset behavior.

…ist tool source

Match the prompt change in 5cc8e52: the CronDelete parameter
description and invalid-id error now say "ULID" only (not
"ULID or legacy 8-hex"), and the CronList id doc comment likewise.
The validation regex is unchanged so loading any legacy 8-hex tasks
from disk still works.

…into kimi-code-v2

Pull the 8 new upstream commits on top of the resolved goal-parity merge.
Reconciled where upstream now overlaps the parity work:

- update-goal: take origin's reimplementation (d9e411f) — no-goal
  fallbacks return a plain result, not a tool error. Dropped parity's
  contradicting "fail as a tool error" test; origin's goal-tools.test.ts
  covers the non-error behavior.
- promptService: keep parity's steer-buffer semantics (gap G24) — steers
  survive a cancelled/failed turn and flush into the next turn. Did not
  re-adopt origin's turn-result observation that discards them; kept
  parity's compaction-defer feature. Updated the retained test to the new
  LoopRunResult shape.
- goalService: keep the imports still used by the surviving goal-outcome
  code; drop TurnResult (no longer referenced after the upstream merge).
- goal.test.ts: adopt the reorganized test path (test/agent/goal) and its
  relative imports; keep the activity-lease import used by the
  continuation tests.

Fast catch-up merge; no conflicts. Brings in tool-args JSON Schema format
validation (adds ajv/ajv-formats deps), cron tool-source cleanup, and test
file tidy. No overlap with the goal-parity work.

It round-tripped restore over a hardcoded local dataset
(kimi-code-mini-bench/.vitest-results) that is not in the repo, so it
vacuously passed everywhere else. Removed at the original author's
request.

…test

The fuzz-style invariant test now drives the full v1 fallback ladder
([2000, 1000, 768, 512, 384, 256]) for over-budget inputs, which takes
longer than the default 5s boundary in this environment. Give it 30s.

- agent/task/manager.test.ts -> taskManager.test.ts (no manager.ts in
  agent/task; disambiguate from taskService.test.ts).
- app/cron/persist.test.ts -> cronTaskPersistenceService.test.ts (mirrors
  the module it covers; agent/task/persist.test.ts mirrors
  agent/task/persist.ts, so it is left as-is).
- agent/contextMemory/message.test.ts -> message-history.test.ts (its
  describe is 'message history (IAgentContextMemoryService)'; the dir
  already names the domain).

- sessionLifecycle: get/list no longer return a session whose cold resume is
  still in flight, so callers never observe a half-initialized handle; resume
  remains the way to await a fully restored handle
- messageLegacy: reduce the transcript from the main agent's in-memory wire
  journal instead of re-reading wire.jsonl; AgentWireRecordService now keeps
  the journal current with live dispatch so cold and live sessions both read a
  consistent, full transcript

micro-compaction only exists in legacy agent-core; v2 has no such mechanism. Update two comments that still cited it:

- fullCompactionService: the real reason not to project here is that llmRequester already projects once.

- swarmService: context.spliced consumers no longer include micro-compaction bookkeeping.

…into kimi-code-v2

…into kimi-code-v2

Since d5e1d76 every wire append rides the async persist queue whenever
a blob service is registered, but AgentWireRecordService.flush() only
awaited the log store. Callers - including the session-close path -
could complete a flush while records were still in flight on the queue,
and record-order assertions in tests raced it. Await the wire service
flush, which drains the persist queue, before flushing the log.

…ontinuation driver

The per-turn-boundary reminder test predates the goal continuation
driver and never passed: its second explicit prompt raced the
auto-launched continuation turn, which correctly holds the turn lane.
Treat the continuation turn as the second boundary and end it
deterministically by completing the goal through UpdateGoal, keeping
the once-per-boundary (never per-step) assertion.

…exhausted

Previously a goal whose hard budget was reached mid-turn was only
flipped to blocked while the turn kept running unbounded: the loop
continues unconditionally after a tool-calls step, and steer flushes or
Stop hooks could extend the turn indefinitely past the budget.

Now, when the over-budget step requested tool calls, a goal_budget_stop
system reminder is appended after the tool results telling the model the
goal is blocked (resumable via /goal resume), to stop immediately, that
further tool calls will be rejected, and to write a brief final status
message. The model gets exactly one grace step, during which tool calls
are answered with a soft rejection instead of executing. After the grace
step - or when the over-budget step had no pending tool calls - a new
AfterStepContext.stopTurn flag ends the turn, honored by the loop with
precedence over tool_calls and hook-set continue so nothing can extend
past the stop. The grace grant also respects maxStepsPerTurn so it can
never turn a budget stop into a max-steps turn failure.

Turn launch is gated as well: a prompt arriving while the active goal is
already over budget (e.g. after resuming an exhausted goal) blocks the
goal before the turn is marked goal-driven, so turnsUsed no longer
drifts, no spurious goal_continued telemetry fires, and the prompt runs
as an ordinary turn with the blocked-goal note injected.

This deliberately diverges from agent-core v1, which hard-stops with
zero grace and answers a prompt on an exhausted goal with a synthetic
model-less turn: budget overshoot is now bounded at one closing step in
exchange for consumed tool results and a user-facing wrap-up message.